﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using EvertonApp.AdminWeb.Controllers.Proxy;
using EvertonApp.AdminWeb.Models;
using EvertonApp.Transporte;

namespace EvertonApp.AdminWeb.Controllers
{
    public class PostController : Controller
    {

        private static Usuario _usuario = new Usuario
        {
            IdUsuario = Guid.NewGuid(),
            Nombre = "Admin",
            Email = "admin@gmail.com",
            Password = "45678"
        };

        //
        // GET: /Post/

        public ActionResult Index()
        {
            PostModel modeloPost = (PostModel)Session["Posts"];

            PostProxy proxy = new PostProxy();

            List<IPosteable> postsAux = (List<IPosteable>)proxy.Get();

            if (modeloPost == null)
            {
                modeloPost = new PostModel();
                modeloPost.Posts = new List<IPosteable>();
            }

            modeloPost.Posts = postsAux;
            modeloPost.desdeFormulario = true;
            modeloPost.PostsFiltrados = new List<IPosteable>();

            modeloPost.Titulo = String.Empty;
            modeloPost.Descripcion = String.Empty;
            modeloPost.FechaCreacion = DateTime.Today;

            Session["Posts"] = modeloPost;

            return View(modeloPost);
        }

        public ActionResult _grillaPosts(PostModel modelo)
        {
            return View(modelo);
        }


        // Guardar Hilos o Noticias

        public ActionResult Guardar(PostModel modelo)
        {
            PostProxy proxy = new PostProxy();

            if (modelo.desdeFormulario)
            {

                if (modelo.TipoPost == "Noticia")
                {
                    Noticia post = new Noticia()
                    {
                        IdHilo = modelo.IdPost,
                        CreadoPor = modelo.CreadoPor ?? _usuario,
                        Descripcion = modelo.Descripcion,
                        FechaCreacion = modelo.FechaCreacion == default(DateTime) ? DateTime.Today : modelo.FechaCreacion,
                        Editado = (modelo.FechaCreacion != default(DateTime)),
                        NumeroComentarios = modelo.NumeroComentarios,
                        Titulo = modelo.Titulo
                    };
                    if (modelo.IdPost == new Guid())
                    {
                        proxy.Post(post, Tipo.NOTICIA);
                    }else
                    {
                        proxy.Put(post.IdHilo, post, Tipo.NOTICIA);
                    }
                }else
                {
                    Hilo post = new Hilo()
                    {
                        IdHilo = modelo.IdPost,
                        CreadoPor = modelo.CreadoPor ?? _usuario,
                        Descripcion = modelo.Descripcion,
                        FechaCreacion = modelo.FechaCreacion == default(DateTime) ? DateTime.Today : modelo.FechaCreacion,
                        Editado = (modelo.FechaCreacion != default(DateTime)),
                        NumeroComentarios = modelo.NumeroComentarios,
                        Titulo = modelo.Titulo
                    };
                    if (modelo.IdPost == new Guid())
                    {
                        proxy.Post(post, Tipo.HILO);
                    }
                    else
                    {
                        proxy.Put(post.IdHilo, post, Tipo.HILO);
                    }
                }
            }

            List<IPosteable> postsAux = (List<IPosteable>)proxy.Get();

            modelo.Posts = postsAux;

            return PartialView("_grillaPosts", modelo);
        }


        // Guardar Eventos
        // con Direccion y FechaEvento

        public ActionResult GuardarEvento(PostModel modelo)
        {
            PostProxy proxy = new PostProxy();

            if (modelo.desdeFormulario)
            {
                Evento post = new Evento()
                                  {
                                      IdHilo = modelo.IdPost,
                                      CreadoPor = modelo.CreadoPor ?? _usuario,
                                      Descripcion = modelo.Descripcion,
                                      FechaCreacion =
                                          modelo.FechaCreacion == default(DateTime)
                                              ? DateTime.Today
                                              : modelo.FechaCreacion,
                                      Editado = (modelo.FechaCreacion != default(DateTime)),
                                      NumeroComentarios = modelo.NumeroComentarios,
                                      Titulo = modelo.Titulo,
                                      Direccion = modelo.Direccion,
                                      FechaEvento = modelo.FechaEvento
                                  };

                if (modelo.IdPost == new Guid())
                {
                    proxy.Post(post, Tipo.EVENTO);
                }
                else
                {
                    proxy.Put(post.IdHilo, post, Tipo.EVENTO);
                }
            }
            List<IPosteable> postsAux = (List<IPosteable>)proxy.Get();

            modelo.Posts = postsAux;

            return PartialView("_grillaPosts", modelo);
        }


        //
        // POST: /Post/Create

        [HttpPost]
        public ActionResult Create()
        {
            PostModel modeloPost = new PostModel();
            modeloPost.desdeFormulario = true;

            return PartialView("Details", modeloPost);
        }

        // Edit Hilo o Noticia

        [HttpPost]
        public ActionResult Edit(Guid IdHilo, String Tipo)
        {
            PostModel modeloPost = new PostModel();
            PostProxy proxy = new PostProxy();

            IPosteable postDetail = null;
            switch (Tipo)
            {
                case "Noticia" :
                    postDetail = proxy.Get(IdHilo, Proxy.Tipo.NOTICIA);
                    postDetail.Tipo = "Noticia";
                    break;
                case "Hilo" :
                    postDetail = proxy.Get(IdHilo, Proxy.Tipo.HILO);
                    postDetail.Tipo = "Hilo";
                    break;
            }

            if (postDetail != null)
            {
                modeloPost.IdPost = postDetail.IdHilo;
                modeloPost.Titulo = postDetail.Titulo;
                modeloPost.Descripcion = postDetail.Descripcion;
                modeloPost.Editado = true;
                modeloPost.FechaCreacion = postDetail.FechaCreacion;
                modeloPost.CreadoPor = postDetail.CreadoPor;
                modeloPost.NumeroComentarios = postDetail.NumeroComentarios;
                modeloPost.TipoPost = postDetail.Tipo;
                modeloPost.desdeFormulario = true;
            }

            return PartialView("Details", modeloPost);
        }


        // Edit Evento
        // formulario con Direccion y FechaEvento
        [HttpPost]
        public ActionResult EditEvento(Guid IdHilo, String Tipo)
        {
            PostModel modeloPost = new PostModel();
            PostProxy proxy = new PostProxy();

            Evento postDetail =  (Evento) proxy.Get(IdHilo, Proxy.Tipo.EVENTO);
            
            if (postDetail != null)
            {
                modeloPost.IdPost = postDetail.IdHilo;
                modeloPost.Titulo = postDetail.Titulo;
                modeloPost.Descripcion = postDetail.Descripcion;
                modeloPost.Editado = true;
                modeloPost.Direccion = postDetail.Direccion;
                modeloPost.FechaEvento = postDetail.FechaEvento;
                modeloPost.FechaCreacion = postDetail.FechaCreacion;
                modeloPost.CreadoPor = postDetail.CreadoPor;
                modeloPost.NumeroComentarios = postDetail.NumeroComentarios;
                modeloPost.TipoPost = "Evento";
                modeloPost.desdeFormulario = true;

            }

            return PartialView("EventoDetails", modeloPost);
        }

      
        // Eliminar un elemento Posteable
         
        public ActionResult Delete(Guid idHilo)
        {
            PostModel postsModel = (PostModel)Session["Posts"];

            foreach (var item in postsModel.Posts)
            {
                if (item.IdHilo == idHilo)
                {
                    postsModel.Posts.Remove(item);

                    PostProxy proxy = new PostProxy();

                    bool postDetail = false;

                    switch (item.Tipo)
                    {
                        case "Noticia":
                            postDetail = proxy.Delete(idHilo, Tipo.NOTICIA);
                            break;
                        case "Evento":
                            postDetail = proxy.Delete(idHilo, Tipo.EVENTO);
                            break;
                        default:
                            postDetail = proxy.Delete(idHilo, Tipo.HILO);
                            break;
                    }
                    break;
                }
            }

            Session["Posts"] = postsModel;

            return PartialView("_grillaPosts", postsModel);
        }

        // Filtra posts
        // Segun Titulo, Descripcion o Nombre de usuario que lo ha creado
        // TODO: buscar por fechas

        public ActionResult FiltroPost(PostModel modelo)
        {
            PostModel postsModel = (PostModel)Session["Posts"];
            PostProxy proxy = new PostProxy();

            if (!modelo.desdeFormulario && postsModel.PostsFiltrados != null && postsModel.PostsFiltrados.Count > 0)
            {
                if (modelo.Posts == null)
                    modelo.Posts = new List<IPosteable>();
                modelo.Posts = postsModel.PostsFiltrados;
            }
            else
            {


                List<IPosteable> posts = (List<IPosteable>)proxy.Get();
                List<IPosteable> postsFiltrados = posts.Where(post => post.Titulo.ToUpper().Contains(modelo.Filtro == null ? String.Empty : modelo.Filtro.ToUpper())
                                                                    && post.Descripcion.ToUpper().Contains(modelo.Filtro == null ? String.Empty : modelo.Filtro.ToUpper())
                                                                    && post.CreadoPor.Nombre.ToUpper().Contains(modelo.Filtro == null ? String.Empty : modelo.Filtro.ToUpper())).ToList();
                modelo.Posts = postsFiltrados;
                postsModel.PostsFiltrados = postsFiltrados;

                Session["Posts"] = postsModel;
            }

            return PartialView("_grillaPosts", modelo);
        }




        /*****************************************/
        //   Comentarios 
        /*****************************************/


        //
        // GET: /Comentario/

        public ActionResult IndexComentario(Guid idPost)
        { 
            ComentarioModel modeloComentario = (ComentarioModel)Session["Comentarios"];

            ComentarioProxy proxy = new ComentarioProxy();

            List<Comentario> comentariosAux = (List<Comentario>)proxy.Get().Where(com => com.HiloId == idPost).ToList();



            if (modeloComentario == null)
            {
                modeloComentario = new ComentarioModel();
                modeloComentario.Comentarios = new List<Comentario>();
            }

            modeloComentario.Comentarios = comentariosAux;
            modeloComentario.desdeFormulario = true;
            modeloComentario.ComentariosFiltrados = new List<Comentario>();

            modeloComentario.Filtro = String.Empty;

            Session["Comentarios"] = modeloComentario;

            return View(modeloComentario);
        }

        public ActionResult _grillaComentarios(ComentarioModel modelo)
        {
            return View(modelo);
        }

        // Guardar Comentario

        public ActionResult GuardarComentario(ComentarioModel modelo)
        {
            ComentarioProxy proxy = new ComentarioProxy();

            if (modelo.desdeFormulario)
            {
                Comentario comentario = new Comentario()
                                            {
                                                IdComentario = modelo.IdComentario,
                                                ComentarioId = modelo.ComentarioId,
                                                CreadoPor = modelo.CreadoPor,
                                                Descripcion = modelo.Descripcion,
                                                FechaCreacion = modelo.FechaCreacion == default(DateTime) ? DateTime.Today : modelo.FechaCreacion,
                                                Editado = (modelo.FechaCreacion != default(DateTime)),
                                                HiloId = modelo.HiloId
                                            };

                if (modelo.IdComentario == new Guid())
                {
                    proxy.Post(comentario);
                }
                else
                {
                    proxy.Put(comentario.IdComentario, comentario);
                }
            }
            List<Comentario> comentariosAux = (List<Comentario>)proxy.Get();

            modelo.Comentarios = comentariosAux;

            return PartialView("_grillaComentarios", modelo);
        }


        //
        // POST: /Comentario/Create

        [HttpPost]
        public ActionResult CreateComentario()
        {
            ComentarioModel modeloComentario = new ComentarioModel();
            modeloComentario.desdeFormulario = true;

            return PartialView("ModalComentario", modeloComentario);
        }



        // Edit Comentario
        
        [HttpPost]
        public ActionResult EditComentario(Guid idComentario)
        {
            ComentarioModel modeloComentario = new ComentarioModel();
            ComentarioProxy proxy = new ComentarioProxy();

            Comentario modelo = (Comentario)proxy.Get(idComentario);

            if (modelo != null)
            {

                modeloComentario.IdComentario = modelo.IdComentario;
                modeloComentario.ComentarioId = modelo.ComentarioId;
                modeloComentario.CreadoPor = modelo.CreadoPor;
                modeloComentario.Descripcion = modelo.Descripcion;
                modeloComentario.FechaCreacion = modelo.FechaCreacion == default(DateTime) ? DateTime.Today : modelo.FechaCreacion;
                modeloComentario.Editado = (modelo.FechaCreacion != default(DateTime));
                modeloComentario.HiloId = modelo.HiloId;
                modeloComentario.desdeFormulario = true;

            }

            return PartialView("ModalComentario", modeloComentario);
        }


        // Eliminar un elemento Comentarioeable

        public ActionResult DeleteComentario(Guid idComentario)
        {
            ComentarioModel comentariosModel = (ComentarioModel)Session["Comentarios"];

            foreach (var item in comentariosModel.Comentarios)
            {
                if (item.IdComentario == idComentario)
                {
                    comentariosModel.Comentarios.Remove(item);

                    ComentarioProxy proxy = new ComentarioProxy();

                    proxy.Delete(idComentario);
                }
            }

            Session["Comentarios"] = comentariosModel;

            return PartialView("_grillaComentarios", comentariosModel);
        }

        // Filtra comentarios
        // Segun Titulo, Descripcion o Nombre de usuario que lo ha creado
        // TODO: buscar por fechas

        public ActionResult FiltroComentario(ComentarioModel modelo)
        {

            throw new Exception("no implementado");
        } 
    }
}
